package outman.weibo.util;

import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.HttpVersion;
import org.apache.http.ParseException;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.params.ConnRouteParams;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;

import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.net.wifi.WifiManager;
import android.util.Log;

public class HttpUtil {

    private static final String TAG = "HttpUtil";

    private static final int SOCKET_TIMEOUT = 200000;
    private static final int CONNECT_TIMEOUT = 50000;

    public static String doGet(HttpGet get) {
	HttpClient client = getNewHttpClient();

	HttpResponse response;

	try {
	    response = client.execute(get);
	    return EntityUtils.toString(response.getEntity());
	} catch (Exception e) {
	    e.printStackTrace();
	    Log.i(TAG, "doGet failed : " + e.getMessage());
	}

	return null;
    }

    public static HttpClient getNewHttpClient() {
	KeyStore trustStore;
	try {
	    trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
	    trustStore.load(null, null);

	    SSLSocketFactory sf = new MySSLSocketFactory(trustStore);
	    sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

	    HttpParams params = new BasicHttpParams();

	    HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
	    HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);

	    SchemeRegistry registry = new SchemeRegistry();
	    registry.register(new Scheme("http", PlainSocketFactory
		    .getSocketFactory(), 80));
	    registry.register(new Scheme("https", sf, 443));

	    ClientConnectionManager ccm = new ThreadSafeClientConnManager(
		    params, registry);

	    // Set the default socket timeout (SO_TIMEOUT) // in
	    // milliseconds which is the timeout for waiting for data.
	    HttpConnectionParams.setConnectionTimeout(params, CONNECT_TIMEOUT);
	    HttpConnectionParams.setSoTimeout(params, SOCKET_TIMEOUT);
	    HttpClient client = new DefaultHttpClient(ccm, params);

	    return client;

	} catch (Exception e) {
	    e.printStackTrace();
	    return new DefaultHttpClient();
	}
    }

    public static HttpClient getHttpClient() {
	BasicHttpParams httpParams = new BasicHttpParams();
	// Set the default socket time out (SO_TIMEOUT) in milliseconds which is
	// the timeout for waiting for data
	HttpConnectionParams.setSoTimeout(httpParams, SOCKET_TIMEOUT);
	HttpConnectionParams.setConnectionTimeout(httpParams, CONNECT_TIMEOUT);

	HttpClient client = new DefaultHttpClient(httpParams);
	return client;
    }

    /**
     * Get a HttpClient object which is setting correctly
     * 
     * @param context
     *            :context of activity
     * @return HttpClient : HttpClient object
     */
    public static HttpClient getHttpClient(Context context) {

	HttpClient client = getHttpClient();

	getAPN(client, context);

	return client;
    }

    private static void getAPN(HttpClient client, Context context) {
	WifiManager wifiManager = (WifiManager) context
		.getSystemService(Context.WIFI_SERVICE);
	if (!wifiManager.isWifiEnabled()) {
	    // 获取当前正在使用的APN接入点
	    Uri uri = Uri.parse("content://telephony/carriers/preferapn");
	    Cursor mCursor = context.getContentResolver().query(uri, null,
		    null, null, null);
	    if (mCursor != null && mCursor.moveToFirst()) {
		// 游标移至第一条记录，当然也只有一条
		String proxyStr = mCursor.getString(mCursor
			.getColumnIndex("proxy"));
		if (proxyStr != null && proxyStr.trim().length() > 0) {
		    HttpHost proxy = new HttpHost(proxyStr, 80);
		    client.getParams().setParameter(
			    ConnRouteParams.DEFAULT_PROXY, proxy);
		}
		mCursor.close();
	    }
	}
    }

    /**
     * 对应于需要获取APN接入点的情况
     * 
     * @param context
     * @return
     */
    public static HttpClient getNewHttpClient(Context context) {

	try {

	    HttpClient client = getNewHttpClient();

	    getAPN(client, context);
	    return client;
	} catch (Exception e) {
	    return new DefaultHttpClient();
	}
    }

    public static class MySSLSocketFactory extends SSLSocketFactory {
	SSLContext sslContext = SSLContext.getInstance("TLS");

	public MySSLSocketFactory(KeyStore truststore)
		throws NoSuchAlgorithmException, KeyManagementException,
		KeyStoreException, UnrecoverableKeyException {
	    super(truststore);

	    TrustManager tm = new X509TrustManager() {
		public void checkClientTrusted(X509Certificate[] chain,
			String authType) throws CertificateException {
		}

		public void checkServerTrusted(X509Certificate[] chain,
			String authType) throws CertificateException {
		}

		public X509Certificate[] getAcceptedIssuers() {
		    return null;
		}
	    };

	    sslContext.init(null, new TrustManager[] { tm }, null);
	}

	@Override
	public Socket createSocket(Socket socket, String host, int port,
		boolean autoClose) throws IOException, UnknownHostException {
	    return sslContext.getSocketFactory().createSocket(socket, host,
		    port, autoClose);
	}

	@Override
	public Socket createSocket() throws IOException {
	    return sslContext.getSocketFactory().createSocket();
	}
    }

}
